home *** CD-ROM | disk | FTP | other *** search
/ Aminet 7 / Aminet 7 - August 1995.iso / Aminet / misc / sci / RARS_Amiga_3.lha / RARS / oscar.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-05-27  |  5.4 KB  |  237 lines
  1. // A RARS-car by Oscar Gustafsson, y92oscgu@isy.liu.se
  2. // Enjoy
  3.  
  4. #include <fstream.h>
  5. #include <iostream.h>
  6. #include <iomanip.h>
  7. #include <string.h>
  8. #include <stdlib.h>
  9. #include <math.h>
  10. #include "car.h"
  11.  
  12. const double    KURV_FART_KONST = 5.8;
  13. const double    KURV_BROMS = -24.0;
  14. const double    RAK_BROMS = -28.0;
  15. const double    RAK_BROMS_KVOT = .91;
  16. const double RAK_BROMS_KONST = 10;
  17. const double    BIG_SLIP = 20.0;
  18. const double    STEER_GAIN = .8;
  19. const double    DAMP_GAIN = 2.0;
  20. const double    DELTA_LANE = 1.5;
  21. const double    WANTED_DIST = 10.0;
  22. const double    BIG_RAD = 3.0;
  23. const double    HS_RAD = 500;
  24.  
  25. // ofstream filut("osccar2c.dat");
  26.  
  27. double          absolut(double x)
  28. {
  29.     if (x < 0)
  30.     return -x;
  31.     else
  32.     return x;
  33. }
  34.  
  35.  
  36. double          kurv_fart(double radius)
  37. {
  38.     double          rad;
  39.     if (!radius)
  40.     return 250.0;
  41.     rad = radius < 0 ? -radius : radius;
  42.  
  43.     return (KURV_FART_KONST * sqrt(rad));
  44. }
  45.  
  46. double          kurv_kaning(double radius)
  47. {
  48.     if (absolut(radius > 500))
  49.     return 7.0;
  50.     else
  51.     return 5.0;
  52. }
  53.  
  54. double          krit_avst(double v0, double v1, double a)
  55. {
  56.     double          dv;
  57.     double          utv;
  58.     dv = v1 - v0;
  59.     if (dv > 0.0)
  60.     return 0.0;
  61.     utv = (v0 + .5 * dv) * dv / a;
  62.     return utv;
  63. }
  64.  
  65. con_vec         OscCar2(situation& s)
  66. {
  67.     int             brake = 0;
  68.     const char      name[] = "OscCar2";
  69.     static int      init_flag = 1, high_speed=0;
  70.     con_vec         result;
  71.     double          alpha,
  72.             vc;
  73.     static double   lane = -10000;
  74.     static double   speed_next = 250;
  75.     static double   speed_goal = 250;
  76.     double          to_end,
  77.             bias,
  78.             width,
  79.             speed_after;
  80.     static double   prev_rad = 10000.0, prev_len = 10000.0;
  81.  
  82.     if (init_flag == 1) {
  83.     my_name_is(name);
  84.     init_flag = 0;
  85.     result.alpha = result.vc = 0;
  86.     return result;
  87.     }
  88.     if (stuck(s.backward, s.v, s.vn, s.to_lft, s.to_rgt, &result.alpha, &result.vc)) {
  89.     return result;
  90.     }
  91.     width = s.to_lft + s.to_rgt;
  92.  
  93.     if (lane < -9000)
  94.     lane = s.to_lft;
  95.  
  96.     if(s.nex_len<1.2 && s.nex_len != 0 && ((s.cur_rad == 0) ||
  97.         absolut(s.cur_rad)>HS_RAD) && (absolut(s.after_rad)>HS_RAD || 
  98.         s.after_rad == 0))
  99.     {
  100.    //           filut << "Picaboo" << endl;
  101.         speed_next = kurv_fart(absolut(s.nex_rad)+(width-WANTED_DIST)/(1-cos(s.nex_len)));
  102.    //           filut << "   " << speed_next << endl;
  103.         high_speed = 2;
  104.     }
  105.  
  106.     if(prev_len != s.cur_len || prev_rad != s.cur_rad)
  107.     {
  108.         prev_rad = s.cur_rad;
  109.         prev_len = s.cur_len;
  110.         if(high_speed)
  111.             high_speed--;
  112.     }
  113.     
  114.     
  115.     if (s.cur_rad == 0) {
  116.     bias = 0.0;
  117.     speed_goal = s.v + 50;
  118.     if (s.nex_rad == 0)
  119.         speed_next = 250;
  120.     else {
  121.         if(!high_speed)
  122.             speed_next = kurv_fart(absolut(s.nex_rad) + WANTED_DIST);
  123.         if (s.nex_rad < 0)
  124.                 lane = width - WANTED_DIST;
  125.             else
  126.                 lane = WANTED_DIST;
  127.         }
  128.     }
  129.     else
  130.     {
  131.     if ((s.nex_rad * s.cur_rad < 0) || (s.nex_rad == 0 && s.after_rad * s.cur_rad < 0)) {
  132.         if (s.to_end < s.cur_len / 2)
  133.         lane = width / 2;
  134.         if (s.to_end < s.cur_len / 6)
  135.         if (s.cur_rad < 0)
  136.             lane = WANTED_DIST;
  137.         else
  138.             lane = width - WANTED_DIST;
  139.     }
  140.     else
  141.     {
  142.         if (s.cur_rad < 0)
  143.         lane = width - WANTED_DIST;
  144.         else
  145.         lane = WANTED_DIST;
  146.     }
  147.     
  148.  
  149.     if(high_speed==1)
  150.         speed_goal = kurv_fart(absolut(s.cur_rad)+width/(1-cos(s.cur_len)));
  151.     else
  152.     {
  153.     if (s.cur_rad < 0)
  154.         speed_goal = kurv_fart(width - lane - s.cur_rad);
  155.     else
  156.         speed_goal = kurv_fart(s.cur_rad + lane);
  157.  
  158.     if (s.cur_len > BIG_RAD && s.to_end < s.cur_len)
  159.         speed_goal = kurv_fart(absolut(s.cur_rad) + width / 2);
  160.     }
  161.  
  162.     bias = (s.v * s.v / (speed_goal * speed_goal)) * atan(BIG_SLIP / speed_goal);
  163.     if (s.cur_rad < 0.0)
  164.         bias = -bias;
  165.  
  166.     if(high_speed != 2)
  167.         if (s.nex_rad == 0)
  168.         speed_next = 250;
  169.         else if (s.nex_rad < 0)
  170.         speed_next = kurv_fart(WANTED_DIST - s.nex_rad);
  171.     else
  172.         speed_next = kurv_fart(s.nex_rad + WANTED_DIST);
  173.     
  174.     }
  175.  
  176.     alpha = STEER_GAIN * (s.to_lft - lane) / width - DAMP_GAIN * s.vn / s.v + bias;
  177.  
  178.     if (absolut(alpha) > 1.6)
  179.     alpha = s.cur_rad < 0 ? -1.6 : 1.6;
  180.  
  181.     if (s.cur_rad == 0) {
  182.     if (s.to_end < krit_avst(s.v, speed_next, RAK_BROMS)) {
  183.         brake = 1;
  184.     }
  185.     } else if (s.to_end * (absolut(s.cur_rad) + lane) <= krit_avst(s.v, speed_next, KURV_BROMS)) {
  186.     brake = 1;
  187.     }
  188.     if (s.after_rad != 0) {
  189.     speed_after = kurv_fart(absolut(s.after_rad) + WANTED_DIST);
  190.     if (s.cur_rad == 0) {
  191.         if (s.to_end + s.nex_len * (absolut(s.nex_rad) + WANTED_DIST)
  192.         <= krit_avst(s.v, speed_after, KURV_BROMS)) {
  193.         brake = 1;
  194.         }
  195.     } else if (s.nex_rad == 0) {
  196.         if (s.to_end * (absolut(s.cur_rad) + lane) + s.nex_len
  197.         <= krit_avst(s.v, speed_after, KURV_BROMS)) {
  198.         brake = 1;
  199.         }
  200.     } else {
  201.         if (s.to_end * (absolut(s.cur_rad) + lane) + s.nex_len * (absolut(s.nex_rad) + WANTED_DIST)
  202.         <= krit_avst(s.v, speed_after, KURV_BROMS)) {
  203.         brake = 1;
  204.         }
  205.     }
  206.     }
  207.     if (brake)
  208.     if (s.cur_rad == 0) {
  209.         if (s.v > 1.02 * speed_next) {
  210.         vc = s.v - RAK_BROMS_KONST;
  211.         } else if (s.v < 0.98 * speed_next)
  212.         vc = 1.1 * speed_next;
  213.         else
  214.         vc = 0.5 * (s.v + speed_next);
  215.     } else {
  216.         vc = s.v - kurv_kaning(s.cur_rad);
  217.     }
  218.     else if (s.cur_rad == 0)
  219.     vc = s.v + 50;
  220.     else
  221.     vc = .5 * (s.v + speed_goal) / cos(alpha);
  222.  
  223.     if (s.dead_ahead)
  224.     if (s.to_lft > s.to_rgt)
  225.         lane -= DELTA_LANE;
  226.     else
  227.         lane += DELTA_LANE;
  228.  
  229.     //  filut << "Alpha: " << alpha << " Vc: " << vc << " Radie: " <<  s.cur_rad <<" Vg: " <<  speed_goal;
  230.     //  filut << " Vn: " << speed_next<< " V: " << s.v << " Hs: " << high_speed << endl;
  231.  
  232.     result.vc = vc;
  233.     result.alpha = alpha;
  234.     return result;
  235. }
  236.  
  237.